
#include <string.h>

#include "FtpServer.h"
#include "Timer0.h"
#include "Uart1.h"
#include "Uart2.h"
#include "Delay.h"
#include "AtCmd.h"



/* FTP服务器参数 */
#define FTP_SERVER_IP    "120.25.168.77"
#define FTP_PORT         "21"
#define FTP_USERNAME     "car"
#define FTP_PASSWORD     "123456"
#define FTP_FILE_NAME    "/car/car.bin"

// 定义FTP指令集
// #define FTP_CMD_AT       "AT\r\n"
// #define FTP_CMD_START    "AT+CFTPSSTART\r\n"
// #define FTP_CMD_LOGIN    "AT+CFTPSLOGIN=\"120.25.168.77\",21,\"car\",\"123456\",0\r\n"
// #define FTP_CMD_PWD      "AT+CFTPSPWD\r\n"
// #define FTP_CMD_GET      "AT+CFTPSGET=\"/car/car.bin\"\r\n"
// #define FTP_CMD_LOGOUT   "AT+CFTPSLOGOUT\r\n"
// #define FTP_CMD_STOP     "AT+CFTPSSTOP\r\n"

#define FTP_CMD_AT       "AT"
#define FTP_CMD_START    "CFTPSSTART"
#define FTP_CMD_LOGIN    "CFTPSLOGIN"
#define FTP_CMD_PWD      "CFTPSPWD"
#define FTP_CMD_GET      "CFTPSGET"
#define FTP_CMD_LOGOUT   "CFTPSLOGOUT"
#define FTP_CMD_STOP     "CFTPSSTOP"

// 超时定义
#define TIMEOUT_SHORT    1000    // 1秒
#define TIMEOUT_MEDIUM   3000    // 3秒
#define TIMEOUT_LONG     9000    // 9秒

// FTP配置信息字符串
char FtpConfigStr[64] = {0};

// 服务器参数结构体
typedef struct {
    char ip[17];
    char port[6];
    char username[17];
    char password[17];
    char file_name[65];
} FTP_Server_Config;

FTP_Server_Config config = {0};

// FTP_Server_Config ftp_config = {
//     FTP_SERVER_IP,
//     FTP_PORT,
//     FTP_USERNAME,
//     FTP_PASSWORD,
//     FTP_FILE_NAME
// };

// 添加字符串到数组
void AddStringToArray(const char* str, char* array)
{
    // 追加双引号"
    strcat(array, "\"");

    // 复制字符串到数组
    strcat(array, str);
    
    // 追加双引号"
    strcat(array, "\"");
}

// 构建FTP配置信息
static void BuildFtpConfig(FTP_Server_Config *config)
{
    // 构建配置信息字符串
    memset(FtpConfigStr, 0, sizeof(FtpConfigStr));
    AddStringToArray(config->ip, FtpConfigStr);
    strcat(FtpConfigStr, ",");
    strcat(FtpConfigStr, config->port);
    strcat(FtpConfigStr, ",");
    AddStringToArray(config->username, FtpConfigStr);
    strcat(FtpConfigStr, ",");
    AddStringToArray(config->password, FtpConfigStr);
    strcat(FtpConfigStr, ",0");
}

xdata char ftp_file_data[64] = {0};    // 接收缓冲区

// FTP服务状态
typedef enum {
    FTP_IDLE,               // 空闲状态
    FTP_START,              // 开启服务状态
    FTP_LOGIN,              // 登录状态
    FTP_RUNNING,            // 运行状态
    FTP_LOGOUT,             // 登出状态
    FTP_STOP                // 关闭服务状态
} FTP_Server_State;

// 命令执行状态
typedef enum {
    CMD_SEND,               // 发送命令
    CMD_WAIT_REPLY          // 等待回复
} FTP_Command_State;

// 数据处理状态
typedef enum {
    DATA_NONE,              // 无数据
    DATA_WAITING,           // 等待数据
    DATA_RECEIVED,          // 数据已接收
    DATA_ERROR              // 数据错误
} FTP_Data_State;
// 模块状态变量
static FTP_Server_State ftp_state = FTP_IDLE;
static FTP_Command_State cmd_state = CMD_SEND;
static FTP_Data_State data_state = DATA_NONE;

// 计时变量
static uint16_t cmd_start_time = 0;
static uint16_t cmd_timeout = TIMEOUT_SHORT;

// 函数声明
static void HandleDataResponse(void);
static void SendCommand(const char* cmd, uint16_t timeout);
static void ProcessCommandResult(FTP_Server_State next_state);

/**
 * 初始化FTP服务
 */
void FtpServerInit(void)
{
	
    // 重置AT模块并确保FTP服务关闭
    UART2_Send_String(GetAtCommand(FTP_CMD_AT, NULL));
    Delayms(1000);
    UART2_Send_String(GetAtCommand(FTP_CMD_LOGOUT, NULL));
    Delayms(1000);
    UART2_Send_String(GetAtCommand(FTP_CMD_STOP, NULL));
    Delayms(1000);
    
    // 初始化状态
    ftp_state = FTP_IDLE;
    cmd_state = CMD_SEND;
    data_state = DATA_NONE;
}

/**
 * 发送命令并设置超时
 */
static void SendCommand(const char* cmd, uint16_t timeout)
{
    // 清空接收缓冲区
	UART2_Rx_Buffer_Clear();
//    memset(uart2_rx_buffer, 0, sizeof(uart2_rx_buffer));
//    rx_index = 0;
    
    // 发送命令
    UART2_Send_String(cmd);
    
    // 设置超时时间
    cmd_start_time = GetSystemTick();
    cmd_timeout = timeout;
    
    // 更新状态
    cmd_state = CMD_WAIT_REPLY;
}

/**
 * 处理命令执行结果
 */
static void ProcessCommandResult(FTP_Server_State next_state)
{
    if(GetSystemTick() - cmd_start_time > cmd_timeout)
    {
        // 超时，切换到下一状态
        ftp_state = next_state;
        cmd_state = CMD_SEND;
    }
}

/**
 * 处理数据响应
 */
static void HandleDataResponse(void)
{
    switch(data_state)
    {
        case DATA_NONE:
            // 空闲状态，不处理
            break;
            
        case DATA_WAITING:
            if(GetSystemTick() - cmd_start_time > cmd_timeout)
            {

                // 检查是否收到数据
                if(strstr(uart2_rx_buffer, "DATA,") != NULL)
                {
                    data_state = DATA_RECEIVED;
                }
                else if(strstr(uart2_rx_buffer, "ERROR") != NULL)
                {
                    data_state = DATA_ERROR;
                }
                else
                {
                    // 超时未收到有效数据
                    data_state = DATA_NONE;
                }
            }
            break;
            
        case DATA_RECEIVED:
            {
                // 提取数据
                uint16_t dataLength = 0;
                char* dataPtr = strstr(uart2_rx_buffer, "DATA,");
                
                if(dataPtr != NULL)
                {
                    // 解析数据长度
                    dataPtr += strlen("DATA,");
                    while(*dataPtr >= '0' && *dataPtr <= '9')
                    {
                        dataLength = dataLength * 10 + (*dataPtr - '0');
                        dataPtr++;
                    }
                    
                    // 跳过"\r\n"
                    dataPtr += 2;
                    
                    // 复制数据到缓冲区
                    if(dataLength > 0 && dataLength < sizeof(ftp_file_data) - 3)
                    {
                        memset(ftp_file_data, 0, sizeof(ftp_file_data));
                        memcpy(ftp_file_data, dataPtr, dataLength);
                        strcat(ftp_file_data, "\r\n");
                        
                        // 输出数据
                        UART2_Send_String(ftp_file_data);
                    }
                }
                
                // 重置状态
                data_state = DATA_NONE;
            }
            break;
            
        case DATA_ERROR:
            // 处理错误情况
			UART2_Send_String("DATA ERROR!\r\n");
            data_state = DATA_NONE;
            break;
    }
}

/**
 * FTP服务处理函数 - 主状态机
 */
void FTP_Server_Process_Handler(void)
{
    static char *buf_ptr = NULL;
    // 处理主状态机
    switch(ftp_state)
    {
        case FTP_IDLE:
            if(cmd_state == CMD_SEND)
            {
                buf_ptr = GetAtCommand(FTP_CMD_START, NULL);
                // 发送启动命令
                SendCommand(buf_ptr, TIMEOUT_SHORT);
                // SendCommand(GetAtCommand(FTP_CMD_START, NULL), TIMEOUT_SHORT);

                // 构建FTP配置信息
                strcpy(config.ip, FTP_SERVER_IP);// IP地址
                strcpy(config.port, FTP_PORT);// 端口号
                strcpy(config.username, FTP_USERNAME);// 用户名
                strcpy(config.password, FTP_PASSWORD);// 密码
				memset(config.file_name, 0, sizeof(config.file_name)); // 格式化指令缓冲区
                AddStringToArray(FTP_FILE_NAME, config.file_name);// 文件名

                // 构建配置信息字符串
                BuildFtpConfig(&config);
            }
            else
            {
                ProcessCommandResult(FTP_START);
            }
            break;
            
        case FTP_START:
            // 发送登录命令
            if(cmd_state == CMD_SEND)
            {
                buf_ptr = GetAtCommand(FTP_CMD_LOGIN, FtpConfigStr);
                SendCommand(buf_ptr, TIMEOUT_LONG);
                // SendCommand(GetAtCommand(FTP_CMD_LOGIN, FtpConfigStr), TIMEOUT_LONG);
            }
            else
            {
                ProcessCommandResult(FTP_LOGIN);
            }
            break;
            
        case FTP_LOGIN:
            // 发送获当前工作目录命令
            if(cmd_state == CMD_SEND)
            {
                buf_ptr = GetAtCommand(FTP_CMD_PWD, NULL);
                SendCommand(buf_ptr, TIMEOUT_SHORT);
                // SendCommand(GetAtCommand(FTP_CMD_PWD, NULL), TIMEOUT_SHORT);
            }
            else
            {
                ProcessCommandResult(FTP_RUNNING);
            }
            break;

        case FTP_RUNNING:
            if(data_state == DATA_NONE)
            {
                // 发送获取文件命令
                if(cmd_state == CMD_SEND)
                {
                    buf_ptr = GetAtCommand(FTP_CMD_GET, config.file_name);
                    SendCommand(buf_ptr, TIMEOUT_MEDIUM);
                    // SendCommand(GetAtCommand(FTP_CMD_GET, FTP_FILE_NAME), TIMEOUT_MEDIUM);
                }
                else
                {
                    // 命令已发送，等待响应数据
                    if(GetSystemTick() - cmd_start_time > cmd_timeout)
                    {
                        data_state = DATA_WAITING;
                        cmd_state = CMD_SEND;
                        
                        // 设置数据等待超时
                        cmd_start_time = GetSystemTick();
                        cmd_timeout = TIMEOUT_SHORT;
                    }
                }
            }
            // 处理数据响应
            HandleDataResponse();
            break;
            
        case FTP_LOGOUT:
            if(cmd_state == CMD_SEND)
            {
                buf_ptr = GetAtCommand(FTP_CMD_LOGOUT, NULL);
                SendCommand(buf_ptr, TIMEOUT_SHORT);
                // SendCommand(GetAtCommand(FTP_CMD_LOGOUT, NULL), TIMEOUT_SHORT);
            }
            else
            {
                ProcessCommandResult(FTP_STOP);
            }
            break;
            
        case FTP_STOP:
            if(cmd_state == CMD_SEND)
            {
                buf_ptr = GetAtCommand(FTP_CMD_STOP, NULL);
                SendCommand(buf_ptr, TIMEOUT_SHORT);
                // SendCommand(GetAtCommand(FTP_CMD_STOP, NULL), TIMEOUT_SHORT);
            }
            else
            {
                ProcessCommandResult(FTP_IDLE);
            }
            break;
            
        default:
            ftp_state = FTP_IDLE;
            break;
    }
}